home *** CD-ROM | disk | FTP | other *** search
/ Freelog 22 / freelog 22.iso / Prog / Djgpp / GPC2952B.ZIP / info / gpc.i13 < prev    next >
Encoding:
GNU Info File  |  2001-02-09  |  50.2 KB  |  2,623 lines
  1. This is gpc.info, produced by makeinfo version 4.0 from gpc.texi.
  2.  
  3. INFO-DIR-SECTION GNU programming tools
  4. START-INFO-DIR-ENTRY
  5. * GPC: (gpc).                   The GNU Pascal Compiler.
  6. END-INFO-DIR-ENTRY
  7. INFO-DIR-SECTION Individual utilities
  8. START-INFO-DIR-ENTRY
  9. * GPC: (gpc)Invoking GPC.       The GNU Pascal Compiler.
  10. END-INFO-DIR-ENTRY
  11.  
  12.    This file documents the GNU Pascal Compiler.
  13.  
  14.    Copyright (C) 1988, 1996-2001 Free Software Foundation, Inc.
  15.  
  16.    Permission is granted to make and distribute verbatim copies of this
  17. manual provided the copyright notice and this permission notice are
  18. preserved on all copies.
  19.  
  20.    Permission is granted to copy and distribute modified versions of
  21. this manual under the conditions for verbatim copying, provided also
  22. that the sections entitled "GNU General Public License", "The GNU
  23. Project", "The GNU Manifesto" and "Funding for Free Software" are
  24. included exactly as in the original, and provided that the entire
  25. resulting derived work is distributed under the terms of a permission
  26. notice identical to this one.
  27.  
  28.    Permission is granted to copy and distribute translations of this
  29. manual into another language, under the above conditions for modified
  30. versions, except that the sections entitled "GNU General Public
  31. License", "The GNU Project", "The GNU Manifesto" and "Funding for Free
  32. Software" and this permission notice, may be included in translations
  33. approved by the Free Software Foundation instead of in the original
  34. English.
  35.  
  36. 
  37. File: gpc.info,  Node: absolute,  Next: abstract,  Prev: Abs,  Up: Reference
  38.  
  39. absolute
  40. ========
  41.  
  42. Synopsis
  43. --------
  44.  
  45.      var
  46.        VARIABLE NAME: DATA TYPE absolute VARIABLE REFERENCE;
  47.    or
  48.      var
  49.        VARIABLE NAME: DATA TYPE absolute INTEGER EXPRESSION;
  50.  
  51. Description
  52. -----------
  53.  
  54.    The first meaning of the `absolute' directive allows to put a
  55. variable to the address of another one and thus provides a type-casting
  56. mechanism.
  57.  
  58.    In most cases, VARIABLE REFERENCE will be just a variable name, but
  59. GPC also allows arbitrary pointer expressions here. If VARIABLE
  60. REFERENCE has neither a constant address nor is a variable parameter,
  61. GPC prints a warning. This warning is suppressed in "extended syntax"
  62. mode which is switched on by the `--extended-syntax' option or the
  63. `{$X+}' compiler directive.
  64.  
  65.    GPC also allows explicit type casts. Variant records (as defined in
  66. ISO-7185 Standard Pascal), however, have no _guaranteed_ overlaying and
  67. are therefore _not_ suitable for type casts.
  68.  
  69.    The second meaning of `absolute' places a variable at a specified
  70. address. This is useful on machines without virtual memory addressing
  71. for doing certain low-level operations, but should be avoided on
  72. systems with memory protection such as Unix-like systems.  GPC does not
  73. check whether the specified virtual address makes any sense and does
  74. not provide a built-in mechanism to map it to a real address.
  75.  
  76.    GPC warns about this second use of `absolute' unless "extended
  77. syntax" has been requested.
  78.  
  79. Conforming to
  80. -------------
  81.  
  82.    `absolute' is a Borland Pascal extension.
  83.  
  84.    Borland Pascal has a slightly different syntax for the second
  85. meaning related to the addressing scheme of Intel x86 processors
  86. working in real mode.
  87.  
  88.    Allowing arbitrary memory references instead of just variable names
  89. in the first meaning of `absolute' is a GNU Pascal extension.
  90.  
  91. Example
  92. -------
  93.  
  94.      program AbsoluteDemo;
  95.      
  96.      {$X+}
  97.      
  98.      const
  99.        IOMem = $f0000000;
  100.      
  101.      var
  102.        Mem: array [0 .. High (Cardinal)] of Byte absolute 0;
  103.      
  104.        { This address has no actual meaning }
  105.        MyPort: Byte absolute IOMem + $c030;
  106.      
  107.      { Beware: Using any of the variables above will crash
  108.        your program unless you know exactly what you do!
  109.        That's why GPC warns about it without the $X+ directive. }
  110.      
  111.      var
  112.        x: Real;
  113.        a: array [1 .. SizeOf (Real)] of Byte absolute x;
  114.        i: Integer;
  115.        b: Byte absolute a [i];  { GNU extension: non-constant memory reference. }
  116.      
  117.      begin
  118.        x := 3.14;
  119.      
  120.        { Look at the internal representation of a real variable. }
  121.        for i := 1 to SizeOf (Real) do
  122.          Write (a [i] : 4);
  123.        WriteLn;
  124.      
  125.        { The same again, more ugly... }
  126.        for i := 1 to SizeOf (Real) do
  127.          Write (b : 4);
  128.        WriteLn;
  129.      
  130.        { And yes, there's an even more ugly way to do it... }
  131.        for i := 1 to SizeOf (Real) do
  132.          Write (Mem [PtrCard (@x) + i - 1] : 4);
  133.        WriteLn
  134.      end.
  135.  
  136. See also
  137. --------
  138.  
  139.    *Note record::, *Note Type Casts::.
  140.  
  141. 
  142. File: gpc.info,  Node: abstract,  Next: Addr,  Prev: absolute,  Up: Reference
  143.  
  144. abstract
  145. ========
  146.  
  147.    Not yet implemented.
  148.  
  149. Synopsis
  150. --------
  151.  
  152. Description
  153. -----------
  154.  
  155. Conforming to
  156. -------------
  157.  
  158. Example
  159. -------
  160.  
  161. See also
  162. --------
  163.  
  164. 
  165. File: gpc.info,  Node: Addr,  Next: AlignOf,  Prev: abstract,  Up: Reference
  166.  
  167. Addr
  168. ====
  169.  
  170. Synopsis
  171. --------
  172.  
  173.      function Addr (const Foo): Pointer;
  174.  
  175. Description
  176. -----------
  177.  
  178.    `Addr' returns the address of its argument. It is equivalent to the
  179. address operator and provided for compatibility with Borland Pascal
  180. which in turn implements it for backward-compatibility with Turbo
  181. Pascal.
  182.  
  183. Conforming to
  184. -------------
  185.  
  186.    `Addr' is a Borland Pascal extension.
  187.  
  188. Example
  189. -------
  190.  
  191.      program AddrDemo;
  192.      var
  193.        Foo: ^Integer;
  194.        Bar: Integer;
  195.      begin
  196.        Foo := Addr (Bar);  { Let `Foo' point to `Bar'. }
  197.        Bar := 17;
  198.        Foo^ := 42;  { Change the value of `Bar' to 42 }
  199.        WriteLn (Bar)
  200.      end.
  201.  
  202. See also
  203. --------
  204.  
  205.    *Note Operators::.
  206.  
  207. 
  208. File: gpc.info,  Node: AlignOf,  Next: all,  Prev: Addr,  Up: Reference
  209.  
  210. AlignOf
  211. =======
  212.  
  213. Synopsis
  214. --------
  215.  
  216.      function AlignOf (var x): Integer;
  217.  
  218. Description
  219. -----------
  220.  
  221.    Returns the alignment of a type or variable in bytes.
  222.  
  223. Conforming to
  224. -------------
  225.  
  226.    `AlignOf' is a GNU extension.
  227.  
  228. Example
  229. -------
  230.  
  231.      program AlignOfDemo;
  232.      var
  233.        a: Integer;
  234.        b: array [1 .. 8] of Char;
  235.      begin
  236.        WriteLn (AlignOf (a));  { Alignment of `Integer'; usually 4 bytes. }
  237.        WriteLn (AlignOf (b));  { Alignment of `Char'; usually 1 byte. }
  238.      end.
  239.  
  240.    Although the array is bigger than a single char, it is accessed char
  241. by char, so there usually is no need to align it on a 4 byte boundary
  242. or such.  (This may be false on some platforms.)
  243.  
  244. See also
  245. --------
  246.  
  247.    *Note SizeOf::, *Note BitSizeOf::, *Note TypeOf::.
  248.  
  249. 
  250. File: gpc.info,  Node: all,  Next: and,  Prev: AlignOf,  Up: Reference
  251.  
  252. all
  253. ===
  254.  
  255. Synopsis
  256. --------
  257.  
  258.      export foo = all;
  259.  
  260. Description
  261. -----------
  262.  
  263.    `all' is a predefined export interface for Extended Pascal modules.
  264. You can use it to export all identifiers declared in an interface module
  265. automatically.
  266.  
  267. Conforming to
  268. -------------
  269.  
  270.    `All' is a GNU extension.
  271.  
  272. Example
  273. -------
  274.  
  275.      program AllDemo;
  276.      
  277.      import AllInterface in 'allmodule.pas';
  278.      
  279.      begin
  280.        Bar (a);
  281.        WriteLn (b)
  282.      end.
  283.  
  284.      module AllModule interface;
  285.      
  286.      export
  287.        AllInterface = all;  { Same as `AllInterface = (a, b, Bar);' }
  288.      
  289.      var
  290.        a, b: Integer;
  291.      
  292.      procedure Bar (i: Integer);
  293.      
  294.      end.
  295.      
  296.      module AllModule implementation;
  297.      
  298.      procedure Bar (i: Integer);
  299.      begin
  300.        b := a
  301.      end;
  302.      
  303.      to begin do
  304.        a := 42;
  305.      
  306.      end.
  307.  
  308. See also
  309. --------
  310.  
  311.    *Note Modules::.
  312.  
  313. 
  314. File: gpc.info,  Node: and,  Next: and then,  Prev: all,  Up: Reference
  315.  
  316. and
  317. ===
  318.  
  319. Synopsis
  320. --------
  321.  
  322.      operator and (operand1, operand2: Boolean) = Result: Boolean;
  323.    or
  324.      operator and (operand1, operand2: INTEGER TYPE) = Result: INTEGER TYPE;
  325.    or
  326.      procedure and (var operand1: INTEGER TYPE; operand2: INTEGER TYPE);
  327.  
  328. Description
  329. -----------
  330.  
  331.    In GNU Pascal, `and' has three built-in meanings:
  332.  
  333.   1. Logical "and" between two `Boolean'-type expressions.  The result
  334.      of the operation is of `Boolean' type.
  335.  
  336.      By default, `and' acts as a short-circuit operator in GPC:  If the
  337.      first operand is `False', the second operand is not evaluated
  338.      because the result is already known to be `False'. You can change
  339.      this to complete evaluation using the `--no-short-circuit'
  340.      command-line option or the `{$B+}' compiler directive.
  341.  
  342.   2. Bitwise "and" between two integer-type expressions.  The result is
  343.      of the common integer type of both expressions.
  344.  
  345.   3. Use as a "procedure":  `operand1' is "and"ed bitwise with
  346.      `operand2'; the result is stored in `operand1'.
  347.  
  348.  
  349. Conforming to
  350. -------------
  351.  
  352.    The logical `and' operator is defined in ISO-7185 Standard Pascal.
  353.  
  354.    According to ISO, you cannot rely on `and' being a short-circuit
  355. operator.  On the other hand, GPC's default behaviour does _not_
  356. contradict the ISO standard.  (See *Note and_then::.)  However, since
  357. it seems to be a de-facto standard among ISO Pascal compilers to
  358. evaluate both operands of `and', GPC switches to `--no-short-circuit'
  359. mode if one of the language dialect options selecting ISO Pascal, for
  360. instance `--extended-pascal', is given.  Use `--short-circuit' to
  361. override.
  362.  
  363.    Use of `and' as a bitwise operator for integers is a Borland Pascal
  364. extension.
  365.  
  366.    Use of `and' as a "procedure" is a GNU extension.
  367.  
  368. Example
  369. -------
  370.  
  371.      program AndDemo;
  372.      var
  373.        a, b, c: Integer;
  374.      begin
  375.        if (a = 0) and (b = 0) then  { logical `and' }
  376.          c := 1
  377.        else if a and b = 0 then  { bitwise `and' }
  378.          c := 2
  379.        else
  380.          and (c, a)  { same as `c := c and a' }
  381.      end.
  382.  
  383.    Note the difference between the logical `and' and the bitwise `and':
  384. When `a' is 2 and `b' is 4, then `a and b' is 0.  *Beware:*  `a and b
  385. = 0' has nothing to do with `(a = 0) and (b = 0)'!
  386.  
  387.    Since bitwise `and' has a higher priority than the `=' operator,
  388. parentheses are needed in `if (a = 0) and (b = 0)' because otherwise `0
  389. and b' would be calculated first, and the remainder would cause a parse
  390. error.
  391.  
  392. See also
  393. --------
  394.  
  395.    *Note and_then::, *Note and then::, *Note or::, *Note xor::, *Note
  396. Operators::.
  397.  
  398. 
  399. File: gpc.info,  Node: and then,  Next: and_then,  Prev: and,  Up: Reference
  400.  
  401. and then
  402. ========
  403.  
  404. Synopsis
  405. --------
  406.  
  407.      { `and then' is built in. A user-defined operator cannot consist of
  408.         two words. }
  409.      operator and then (operand1, operand2: Boolean) = Result: Boolean;
  410.  
  411. Description
  412. -----------
  413.  
  414.    `and then' is an alias for the short-circuit logical operator
  415. `and_then'.
  416.  
  417. Conforming to
  418. -------------
  419.  
  420.    While `and_then' is defined in ISO-10206 Extended Pascal, `and then'
  421. is a GNU Extension.
  422.  
  423. Example
  424. -------
  425.  
  426.      program AndThenDemo;
  427.      var
  428.        p: ^Integer;
  429.      begin
  430.        New (p);
  431.        ReadLn (p^);
  432.        if (p <> nil) and then (p^ < 42) then  { This is safe. }
  433.          WriteLn (p^, ' is less than 42')
  434.      end.
  435.  
  436. See also
  437. --------
  438.  
  439.    *Note and_then::, *Note and::, *Note or else::.
  440.  
  441. 
  442. File: gpc.info,  Node: and_then,  Next: AnsiChar,  Prev: and then,  Up: Reference
  443.  
  444. and_then
  445. ========
  446.  
  447. Synopsis
  448. --------
  449.  
  450.      operator and_then (operand1, operand2: Boolean) = Result: Boolean;
  451.  
  452. Description
  453. -----------
  454.  
  455.    The `and_then' short-circuit logical operator performs the same
  456. operation as the logical operator `and'.  But while the ISO standard
  457. does not specify anything about the evaluation of the operands of `and'
  458. - they may be evaluated in any order, or not at all - `and_then' has a
  459. well-defined behaviour:  It evaluates the first operand.  If the result
  460. is `False', `and_then' returns `False' without evaluating the second
  461. operand.  If it is `True', the second operand is evaluated and returned.
  462.  
  463.    Since the behaviour described above is the most efficient way to
  464. implement `and', GPC by default treats `and' and `and_then' exactly the
  465. same.  If you want, for some reason, to have both operands of `and'
  466. evaluated completely, you must assign both to temporary variables and
  467. then use `and' - or `and_then', it does not matter.
  468.  
  469. Conforming to
  470. -------------
  471.  
  472.    `and_then' is an ISO-10206 Extended Pascal extension.
  473.  
  474.    Some people think that the ISO standard requires both operands of
  475. `and' to be evaluated.  This is false.  What the ISO standard _does_
  476. say is that you cannot rely on a certain order of evaluation of the
  477. operands of `and'; in particular things like the following program can
  478. crash according to ISO Pascal, although they cannot crash when compiled
  479. with GNU Pascal running in default mode.
  480.  
  481.      program AndBug;
  482.      var
  483.        p: ^Integer;
  484.      begin
  485.        New (p);
  486.        ReadLn (p^);
  487.        if (p <> nil) and (p^ < 42) then  { This is NOT safe! }
  488.          WriteLn ('You''re lucky. But the test could have crashed...')
  489.      end.
  490.  
  491. Example
  492. -------
  493.  
  494.      program And_ThenDemo;
  495.      var
  496.        p: ^Integer;
  497.      begin
  498.        New (p);
  499.        ReadLn (p^);
  500.        if (p <> nil) and_then (p^ < 42) then  { This is safe. }
  501.          WriteLn (p^, ' is less than 42')
  502.      end.
  503.  
  504. See also
  505. --------
  506.  
  507.    *Note and then::, *Note and::, *Note or_else::.
  508.  
  509. 
  510. File: gpc.info,  Node: AnsiChar,  Next: Append,  Prev: and_then,  Up: Reference
  511.  
  512. AnsiChar
  513. ========
  514.  
  515. Synopsis
  516. --------
  517.  
  518.      type
  519.        AnsiChar = Char;
  520.  
  521. Description
  522. -----------
  523.  
  524.    `AnsiChar' is an 8 bit char type. Currently, it is the same as
  525. `Char', but this might change in the future, once `wide chars' (16 bit
  526. chars) will be introduced into GPC. Depending on the platform, `Char'
  527. might be either `AnsiChar' or `WideChar' then.
  528.  
  529. Conforming to
  530. -------------
  531.  
  532.    `AnsiChar' is a Borland Delphi extension.
  533.  
  534. Example
  535. -------
  536.  
  537.      program AnsiCharDemo;
  538.      var
  539.        A: AnsiChar;  { There is nothing special with `AnsiChar'. }
  540.        B: Char;
  541.      begin
  542.        A := 'A';
  543.        A := B
  544.      end.
  545.  
  546. See also
  547. --------
  548.  
  549.    *Note PAnsiChar::, *Note Char::.
  550.  
  551. 
  552. File: gpc.info,  Node: Append,  Next: ArcTan,  Prev: AnsiChar,  Up: Reference
  553.  
  554. Append
  555. ======
  556.  
  557. Synopsis
  558. --------
  559.  
  560.      procedure Append (var F: ANY FILE; [FileName: String;]
  561.                                          [BlockSize: Cardinal]);
  562.  
  563. Description
  564. -----------
  565.  
  566.    `Append' opens a file for writing. If the file does not exist, it is
  567. created. If it does exist, the file pointer is positioned after the
  568. last element.
  569.  
  570.    Like `Rewrite', `Reset' and `Extend' do, `Append' accepts an
  571. optional second and third parameter for the name of the file in the
  572. filesystem and, for untyped files, the block size of the file. (For
  573. details, see *Note Rewrite::.)
  574.  
  575. Conforming to
  576. -------------
  577.  
  578.    `Append', including the `BlockSize' parameter, is a Borland Pascal
  579. extension. ISO-10206 Extended Pascal has *Note Extend:: instead.  The
  580. `FileName' parameter is a GNU extension.
  581.  
  582. Example
  583. -------
  584.  
  585.      program AppendDemo;
  586.      var
  587.        Sample: Text;
  588.      begin
  589.        Assign (Sample, 'sample.txt');
  590.        Rewrite (Sample);
  591.        WriteLn (Sample, 'Hello, World!');  { `sample.txt' now has one line }
  592.        Close (Sample);
  593.      
  594.        { ... }
  595.      
  596.        Append (Sample);
  597.        WriteLn (Sample, 'Hello again!');   { `sample.txt' now has two lines }
  598.        Close (Sample)
  599.      end.
  600.  
  601. See also
  602. --------
  603.  
  604.    *Note Assign::, *Note Reset::, *Note Rewrite::, *Note Update::,
  605. *Note Extend::.
  606.  
  607. 
  608. File: gpc.info,  Node: ArcTan,  Next: Arg,  Prev: Append,  Up: Reference
  609.  
  610. ArcTan
  611. ======
  612.  
  613. Synopsis
  614. --------
  615.  
  616.      function ArcTan (x: Real): Real;
  617.    or
  618.      function ArcTan (z: Complex): Complex;
  619.  
  620. Description
  621. -----------
  622.  
  623.    `ArcTan' returns the (principal value of the) arcus tangent of the
  624. argument. The result is in the range `-pi / 2 < ArcTan (x) < pi / 2'
  625. for real arguments.
  626.  
  627. Conforming to
  628. -------------
  629.  
  630.    The function `ArcTan' is defined in ISO-7185 Standard Pascal; its
  631. application to complex values is defined in ISO-10206 Extended Pascal.
  632.  
  633. Example
  634. -------
  635.  
  636.      program ArcTanDemo;
  637.      begin
  638.        { yields 3.14159 as ArcTan (1) = Pi / 4 }
  639.        WriteLn (4 * ArcTan (1) : 0 : 5)
  640.      end.
  641.  
  642. See also
  643. --------
  644.  
  645.    *Note Sin::, *Note Cos::, *Note Ln::, *Note Arg::.
  646.  
  647. 
  648. File: gpc.info,  Node: Arg,  Next: array,  Prev: ArcTan,  Up: Reference
  649.  
  650. Arg
  651. ===
  652.  
  653. Synopsis
  654. --------
  655.  
  656.      function Arg (z: Complex): Real;
  657.  
  658. Description
  659. -----------
  660.  
  661.    `Arg' returns the complex "argument", i.e. the angle (in radian) in
  662. the complex plane with respect to the real axis, of its parameter `z'.
  663. The result is in the range of `-Pi < Arg (z) <= Pi'.
  664.  
  665. Conforming to
  666. -------------
  667.  
  668.    `Arg' is an ISO-10206 Extended Pascal extension.
  669.  
  670. Example
  671. -------
  672.  
  673.      program ArgDemo;
  674.      var
  675.        z: Complex;
  676.      begin
  677.        z := Cmplx (1, 1);  { 1 + i }
  678.        WriteLn (Arg (z) : 0 : 5)  { yields 0.78540, i.e. Pi / 4 }
  679.      end.
  680.  
  681. See also
  682. --------
  683.  
  684.    *Note ArcTan::, *Note Ln::, *Note Polar::.
  685.  
  686. 
  687. File: gpc.info,  Node: array,  Next: asm,  Prev: Arg,  Up: Reference
  688.  
  689. array
  690. =====
  691.  
  692. Synopsis
  693. --------
  694.  
  695.    In type definitions:
  696.      array [INDEX TYPE] of ELEMENT TYPE
  697.    or
  698.      array [INDEX TYPE, ..., INDEX TYPE] of ELEMENT TYPE
  699.  
  700.    In parameter list declarations:
  701.      array of ELEMENT TYPE
  702.  
  703. Description
  704. -----------
  705.  
  706.    The reserved word `array' is used to define an array type.
  707.  
  708.    @@!!!! arrays in parameter lists
  709.  
  710. Conforming to
  711. -------------
  712.  
  713.    Array types are defined in ISO 7185 Standard Pascal.
  714.  
  715. Example
  716. -------
  717.  
  718.      program ArrayDemo;
  719.      type
  720.        IntArray = array [1 .. 20] of Integer;
  721.        WeekDayChars = array [(Mon, Tue, Wed, Thu, Fri, Sat, Sun)] of Char;
  722.        Foo = array [0 .. 9, 'a' .. 'z', (Baz, Glork1, Fred)] of Real;
  723.        TwoDimIntArray = array [1 .. 10] of IntArray;
  724.        { is equivalent to: }
  725.        TwoDimIntArray2 = array [1 .. 10, 1 .. 20] of Integer;
  726.      
  727.      procedure PrintChars (F: array of Char);
  728.      var
  729.        i: Integer;
  730.      begin
  731.        for i := Low (F) to High (F) do
  732.          WriteLn (F [i])
  733.      end;
  734.      
  735.      var
  736.        Waldo: WeekDayChars;
  737.      
  738.      begin
  739.        Waldo := 'HiWorld';
  740.        PrintChars (Waldo)
  741.      end.
  742.  
  743. See also
  744. --------
  745.  
  746.    *Note Array Types::, *Note High::, *Note Low::
  747.  
  748. 
  749. File: gpc.info,  Node: asm,  Next: asmname,  Prev: array,  Up: Reference
  750.  
  751. asm
  752. ===
  753.  
  754.    (Under construction.)
  755.  
  756. Synopsis
  757. --------
  758.  
  759. Description
  760. -----------
  761.  
  762.    See
  763. `ftp://agnes.dida.physik.uni-essen.de/gnu-pascal/contrib/gpcasm.zip'.
  764.  
  765. Conforming to
  766. -------------
  767.  
  768.    `asm', as implemented in GPC, is a GNU extension. It is mostly
  769. compatible to GCC's `asm', but not compatible to that of Borland Pascal.
  770.  
  771. Example
  772. -------
  773.  
  774. See also
  775. --------
  776.  
  777.    *Note Importing Libraries from Other Languages::, *Note asmname::
  778.  
  779. 
  780. File: gpc.info,  Node: asmname,  Next: Assign,  Prev: asm,  Up: Reference
  781.  
  782. asmname
  783. =======
  784.  
  785. Synopsis
  786. --------
  787.  
  788.    PROCEDURE/FUNCTION HEADER; asmname NAME;
  789.  
  790.    or
  791.  
  792.    VARIABLE DECLARATION; asmname NAME;
  793.  
  794. Description
  795. -----------
  796.  
  797.    The `asmname' directive declares the external name of a procedure,
  798. function or variable. The external name of the routine is given
  799. explicitly as a case-sensitive string constant. This is useful when
  800. interfacing with libraries written in other languages.
  801.  
  802.    With this extension it is possible to access all external functions,
  803. for example the X11 interface functions, and not only those written in
  804. lowercase.
  805.  
  806.    The idea to use `external' for this purpose (to avoid name space
  807. pollution) conflicts with another Borland extension not yet
  808. implemented: In Borland Pascal, the declaration
  809.      procedure Foo; external 'MyLib';
  810.    means that the procedure Foo should be imported by name (`Foo') from
  811. a dynamic link library `mylib.dll'.
  812.  
  813. Conforming to
  814. -------------
  815.  
  816.    `asmname' is a GNU Pascal extension.
  817.  
  818. Example
  819. -------
  820.  
  821.      program AsmnameDemo;
  822.      
  823.      { Make two variables aliases of each other by using `asmname'.
  824.        This is not good style. If you must have aliases for any reason,
  825.        `absolute' declaration may be the lesser evil... }
  826.      var
  827.        Foo: Integer; asmname 'Foo_Bar';
  828.        Bar: Integer; asmname 'Foo_Bar';
  829.      
  830.      { A function from the C library }
  831.      function PutS (Str: CString): Integer; asmname 'puts'; external;
  832.      
  833.      var
  834.        Result: Integer;
  835.      begin
  836.        Result := PutS ('Hello World!');
  837.        WriteLn ('puts wrote ', Result, ' characters (including a newline).');
  838.        Foo := 42;
  839.        WriteLn ('Foo = ', Foo);
  840.        Bar := 17;
  841.        WriteLn ('Setting Bar to 17.');
  842.        WriteLn ('Now, Foo = ', Foo, '!!!')
  843.      end.
  844.  
  845. See also
  846. --------
  847.  
  848.    *Note C::, *Note C_Language::, *Note external::, *Note Importing
  849. Libraries from Other Languages::.
  850.  
  851. 
  852. File: gpc.info,  Node: Assign,  Next: Assigned,  Prev: asmname,  Up: Reference
  853.  
  854. Assign
  855. ======
  856.  
  857.    (Under contruction.)
  858.  
  859. Synopsis
  860. --------
  861.  
  862.      procedure Assign (var F: ANY FILE; FileName: String);
  863.  
  864. Description
  865. -----------
  866.  
  867. Conforming to
  868. -------------
  869.  
  870.    `Assign' is a Borland Pascal extension.
  871.  
  872. Example
  873. -------
  874.  
  875. See also
  876. --------
  877.  
  878.    *Note Reset::, *Note Rewrite::, *Note Update::, *Note Extend::,
  879. *Note Append::.
  880.  
  881. 
  882. File: gpc.info,  Node: Assigned,  Next: attribute,  Prev: Assign,  Up: Reference
  883.  
  884. Assigned
  885. ========
  886.  
  887.    (Under construction.)
  888.  
  889. Synopsis
  890. --------
  891.  
  892.      function Assigned (p: Pointer): Boolean;
  893.    or
  894.      function Assigned (p: PROCEDURAL TYPE): Boolean;
  895.  
  896. Description
  897. -----------
  898.  
  899.    The `Assigned' function returns `True' if the pointer parameter or
  900. the address of the procedural parameter is not `nil'; it returns
  901. `False' if it is `nil'.
  902.  
  903. Conforming to
  904. -------------
  905.  
  906.    `Assigned' is a Borland Pascal extension.
  907.  
  908. Example
  909. -------
  910.  
  911.      program AssignedDemo;
  912.      type
  913.        PInt = ^Integer;
  914.      
  915.      procedure TellIfOdd (p: PInt);
  916.      begin
  917.        if Assigned (p) and then Odd (p^) then
  918.          WriteLn ('The pointer p points to an odd value.')
  919.      end;
  920.      
  921.      var
  922.        foo: Integer;
  923.      begin
  924.        TellIfOdd (nil);
  925.        foo := 1;
  926.        TellIfOdd (@foo);
  927.        foo := 2;
  928.        TellIfOdd (@foo)
  929.      end.
  930.  
  931. See also
  932. --------
  933.  
  934.    *Note Null::, *Note nil::, *Note Pointer::.
  935.  
  936. 
  937. File: gpc.info,  Node: attribute,  Next: begin,  Prev: Assigned,  Up: Reference
  938.  
  939. attribute
  940. =========
  941.  
  942.    (Under construction.)
  943.  
  944. Synopsis
  945. --------
  946.  
  947. Description
  948. -----------
  949.  
  950. Conforming to
  951. -------------
  952.  
  953.    `attribute' is a GNU Pascal extension.
  954.  
  955. Example
  956. -------
  957.  
  958. See also
  959. --------
  960.  
  961. 
  962. File: gpc.info,  Node: begin,  Next: Bind,  Prev: attribute,  Up: Reference
  963.  
  964. begin
  965. =====
  966.  
  967. Synopsis
  968. --------
  969.  
  970.      begin
  971.        STATEMENT;
  972.        STATEMENT;
  973.        ...
  974.        STATEMENT
  975.      end;
  976.  
  977. Description
  978. -----------
  979.  
  980.    The reserved word `begin' opens a `begin ... end' statement which
  981. joins several STATEMENTS to one compound statement.
  982.  
  983. Conforming to
  984. -------------
  985.  
  986.    `begin' is defined in ISO 7185 Standard Pascal
  987.  
  988. Example
  989. -------
  990.  
  991.      program BeginDemo;
  992.      begin
  993.        if True then
  994.          WriteLn ('single statement');
  995.        if True then
  996.          begin                     { clamp statement1 ... }
  997.            WriteLn ('statement1');
  998.            WriteLn ('statement2')
  999.          end                       { ... to statement2 }
  1000.      end.
  1001.  
  1002. See also
  1003. --------
  1004.  
  1005.    *Note begin end Compound Statement::, *Note end::
  1006.  
  1007. 
  1008. File: gpc.info,  Node: Bind,  Next: bindable,  Prev: begin,  Up: Reference
  1009.  
  1010. Bind
  1011. ====
  1012.  
  1013.    (Under construction.)
  1014.  
  1015. Synopsis
  1016. --------
  1017.  
  1018.      procedure Bind (var F: ANY FILE; B: BindingType);
  1019.  
  1020. Description
  1021. -----------
  1022.  
  1023. Conforming to
  1024. -------------
  1025.  
  1026.    `Bind' is an ISO-10206 Extended Pascal extension.
  1027.  
  1028. Example
  1029. -------
  1030.  
  1031. See also
  1032. --------
  1033.  
  1034. 
  1035. File: gpc.info,  Node: bindable,  Next: Binding,  Prev: Bind,  Up: Reference
  1036.  
  1037. bindable
  1038. ========
  1039.  
  1040.    (Under construction.)
  1041.  
  1042. Synopsis
  1043. --------
  1044.  
  1045. Description
  1046. -----------
  1047.  
  1048. Conforming to
  1049. -------------
  1050.  
  1051.    `bindable' is an ISO-10206 Extended Pascal extension.
  1052.  
  1053. Example
  1054. -------
  1055.  
  1056. See also
  1057. --------
  1058.  
  1059. 
  1060. File: gpc.info,  Node: Binding,  Next: BindingType,  Prev: bindable,  Up: Reference
  1061.  
  1062. Binding
  1063. =======
  1064.  
  1065.    (Under construction.)
  1066.  
  1067. Synopsis
  1068. --------
  1069.  
  1070.      function Binding (F: ANY FILE): BindingType;
  1071.  
  1072. Description
  1073. -----------
  1074.  
  1075. Conforming to
  1076. -------------
  1077.  
  1078.    `Binding' is an ISO-10206 Extended Pascal extension.
  1079.  
  1080. Example
  1081. -------
  1082.  
  1083. See also
  1084. --------
  1085.  
  1086. 
  1087. File: gpc.info,  Node: BindingType,  Next: BitSizeOf,  Prev: Binding,  Up: Reference
  1088.  
  1089. BindingType
  1090. ===========
  1091.  
  1092.    (Under construction.)
  1093.  
  1094. Synopsis
  1095. --------
  1096.  
  1097.      type
  1098.        UnixTimeType = LongInt;
  1099.        BindingType = {@@packed} record
  1100.          Bound             : Boolean;
  1101.          Force             : Boolean;      { Can be set to allow binding to
  1102.                                              directories or inaccessible files }
  1103.          Extensions_Valid  : Boolean;
  1104.          Readable          : Boolean;
  1105.          Writable          : Boolean;
  1106.          Executable        : Boolean;
  1107.          Existing          : Boolean;      { Binding points to an existing file }
  1108.          Directory         : Boolean;      { Binding points to an existing
  1109.                                              directory; Existing is False then }
  1110.          Special           : Boolean;      { Binding points to an existing
  1111.                                              special file (device, pipe, socket,
  1112.                                              etc.); `Existing' is False then }
  1113.          SymLink           : Boolean;      { Binding points to a symbolic link }
  1114.          AccessTime,                       { Time of last access }
  1115.          ModificationTime,                 { Time of last modification }
  1116.          ChangeTime        : UnixTimeType; { Time of last change }
  1117.          User,                             { User ID of owner }
  1118.          Group,                            { Group ID of owner }
  1119.          Mode,                             { Access permissions, cf. ChMod }
  1120.          Device,                           { Device the file is on }
  1121.          INode             : Integer;      { Unix INode number }
  1122.          TextBinary        : Boolean;      { Open a Text file in binary mode }
  1123.          Handle            : Integer;      { Can be set to bind a Pascal file to
  1124.                                              a given file handle }
  1125.          Name              : String (Binding_Name_Length)
  1126.        end;
  1127.  
  1128.    (@@ Currently, in GPC, BindingType is not actually packed.)
  1129.  
  1130.    The fields `Bound' and `Name' are required by Extended Pascal.
  1131.  
  1132.    `Binding_Name_Length' is an implementation-defined constant.
  1133.  
  1134. Description
  1135. -----------
  1136.  
  1137. Conforming to
  1138. -------------
  1139.  
  1140.    `BindingType' is an ISO-10206 Extended Pascal extension.
  1141.  
  1142. Example
  1143. -------
  1144.  
  1145. See also
  1146. --------
  1147.  
  1148. 
  1149. File: gpc.info,  Node: BitSizeOf,  Next: BlockRead,  Prev: BindingType,  Up: Reference
  1150.  
  1151. BitSizeOf
  1152. =========
  1153.  
  1154. Synopsis
  1155. --------
  1156.  
  1157.      function BitSizeOf (var x): SizeType;
  1158.  
  1159. Description
  1160. -----------
  1161.  
  1162.    Returns the size of a type or variable in bits.
  1163.  
  1164. Conforming to
  1165. -------------
  1166.  
  1167.    `BitSizeOf' is a GNU Pascal extension.
  1168.  
  1169. Example
  1170. -------
  1171.  
  1172.      program BitSizeOfDemo;
  1173.      var
  1174.        a: Integer;
  1175.        b: array [1 .. 8] of Char;
  1176.        c: Integer (12);
  1177.        d: packed record
  1178.             x: Integer (12);
  1179.             y: 0 .. 3
  1180.           end;
  1181.      begin
  1182.        WriteLn (BitSizeOf (a));    { Size of an `Integer'; usually 32 bits. }
  1183.        WriteLn (BitSizeOf (b));    { Size of eight `Char's; usually 64 bits. }
  1184.        WriteLn (BitSizeOf (c));    { e.g. 16 bits (smallest addressable space). }
  1185.        WriteLn (BitSizeOf (d));    { e.g. 16 }
  1186.        WriteLn (BitSizeOf (d.x));  { 12 }
  1187.        WriteLn (BitSizeOf (d.y))   {  2 }
  1188.      end.
  1189.  
  1190. See also
  1191. --------
  1192.  
  1193.    *Note SizeOf::, *Note AlignOf::, *Note TypeOf::.
  1194.  
  1195. 
  1196. File: gpc.info,  Node: BlockRead,  Next: BlockWrite,  Prev: BitSizeOf,  Up: Reference
  1197.  
  1198. BlockRead
  1199. =========
  1200.  
  1201.    (Under construction.)
  1202.  
  1203. Synopsis
  1204. --------
  1205.  
  1206.      procedure BlockRead (var F: File; var Buffer; Blocks: Integer);
  1207.    or
  1208.      procedure BlockRead (var F: File; var Buffer; Blocks: Integer;
  1209.                           var BlocksRead: Integer);
  1210.  
  1211. Description
  1212. -----------
  1213.  
  1214. Conforming to
  1215. -------------
  1216.  
  1217.    `BlockRead' is a UCSD Pascal extension.
  1218.  
  1219. Example
  1220. -------
  1221.  
  1222. See also
  1223. --------
  1224.  
  1225. 
  1226. File: gpc.info,  Node: BlockWrite,  Next: Boolean,  Prev: BlockRead,  Up: Reference
  1227.  
  1228. BlockWrite
  1229. ==========
  1230.  
  1231.    (Under construction.)
  1232.  
  1233. Synopsis
  1234. --------
  1235.  
  1236.      procedure BlockWrite (var F: File; const Buffer; Blocks: Integer);
  1237.    or
  1238.      procedure BlockWrite (var F: File; const Buffer; Blocks: Integer;
  1239.                            var BlocksWritten: Integer);
  1240.  
  1241. Description
  1242. -----------
  1243.  
  1244. Conforming to
  1245. -------------
  1246.  
  1247.    `BlockWrite' is a UCSD Pascal extension.
  1248.  
  1249. Example
  1250. -------
  1251.  
  1252. See also
  1253. --------
  1254.  
  1255. 
  1256. File: gpc.info,  Node: Boolean,  Next: Break,  Prev: BlockWrite,  Up: Reference
  1257.  
  1258. Boolean
  1259. =======
  1260.  
  1261.    (Under construction.)
  1262.  
  1263. Synopsis
  1264. --------
  1265.  
  1266.      type
  1267.        Boolean = (False, True);
  1268.    or
  1269.      type
  1270.        Boolean (n)  { built-in type class }
  1271.  
  1272. Description
  1273. -----------
  1274.  
  1275. Conforming to
  1276. -------------
  1277.  
  1278.    `Boolean' is defined in ISO-7185 Standard Pascal and supported by
  1279. all known Pascal variants.
  1280.  
  1281.    `Boolean (n)' is a GPC extension.
  1282.  
  1283. Example
  1284. -------
  1285.  
  1286.      program BooleanDemo;
  1287.      var
  1288.        a: Boolean;
  1289.      begin
  1290.        a := True;
  1291.        WriteLn (a)
  1292.      end.
  1293.  
  1294. See also
  1295. --------
  1296.  
  1297. 
  1298. File: gpc.info,  Node: Break,  Next: Byte,  Prev: Boolean,  Up: Reference
  1299.  
  1300. Break
  1301. =====
  1302.  
  1303. Synopsis
  1304. --------
  1305.  
  1306.      Break  { simple statement }
  1307.  
  1308. Description
  1309. -----------
  1310.  
  1311.    With `Break' you can exit the body of the current loop instantly.
  1312. It can only be used within a WHILE, REPEAT or a FOR statement.
  1313.  
  1314. Conforming to
  1315. -------------
  1316.  
  1317.    `Break' is a Borland Pascal extension.
  1318.  
  1319. Example
  1320. -------
  1321.  
  1322.      program BreakDemo;
  1323.      var
  1324.        Foo: Integer;
  1325.      begin
  1326.        while True do
  1327.          begin
  1328.            repeat
  1329.              WriteLn ('Enter a number less than 100:');
  1330.              ReadLn (Foo);
  1331.              if Foo < 100 then
  1332.                Break;             { Exits repeat loop }
  1333.              WriteLn (Foo, ' is not exactly less than 100! Try again...')
  1334.            until False;
  1335.            if Foo > 50 then
  1336.              Break;              { Exits while loop }
  1337.            WriteLn ('The number entered was not greater then 50.')
  1338.          end
  1339.      end.
  1340.  
  1341. See also
  1342. --------
  1343.  
  1344.    *Note Loop Control Statements::, *Note Continue::, *Note Exit::,
  1345. *Note Halt::, *Note Return::, *Note goto::.
  1346.  
  1347. 
  1348. File: gpc.info,  Node: Byte,  Next: ByteBool,  Prev: Break,  Up: Reference
  1349.  
  1350. Byte
  1351. ====
  1352.  
  1353. Synopsis
  1354. --------
  1355.  
  1356.      type
  1357.        Byte  { built-in type }
  1358.  
  1359. Description
  1360. -----------
  1361.  
  1362.    `Byte' is an unsigned integer type which is one "unit" wide.  On
  1363. most platforms one unit has 8 bits, therefore the type is named "byte"
  1364. and usually has a range of `0..255'. (It is the same as *Note
  1365. ByteCard::.)
  1366.  
  1367.    `Byte' in GNU Pascal is compatible to `unsigned char' in GNU C.
  1368.  
  1369.    There are lots of other integer types in GPC, see *Note Integer
  1370. Types::.
  1371.  
  1372. Conforming to
  1373. -------------
  1374.  
  1375.    `Byte' is a Borland Pascal extension. (For something equivalent in
  1376. ISO Pascal, see *Note Subrange Types::.)
  1377.  
  1378. Example
  1379. -------
  1380.  
  1381.      program ByteDemo;
  1382.      var
  1383.        a: Byte;
  1384.      begin
  1385.        a := 42;
  1386.        WriteLn (a)
  1387.      end.
  1388.  
  1389. See also
  1390. --------
  1391.  
  1392.    *Note Integer Types::, *Note Subrange Types::.
  1393.  
  1394. 
  1395. File: gpc.info,  Node: ByteBool,  Next: ByteCard,  Prev: Byte,  Up: Reference
  1396.  
  1397. ByteBool
  1398. ========
  1399.  
  1400.    (Under construction.)
  1401.  
  1402. Synopsis
  1403. --------
  1404.  
  1405.      type
  1406.        ByteBool = Boolean (BitSizeOf (Byte));
  1407.  
  1408. Description
  1409. -----------
  1410.  
  1411. Conforming to
  1412. -------------
  1413.  
  1414. Example
  1415. -------
  1416.  
  1417.      program ByteBoolDemo;
  1418.      var
  1419.        a: ByteBool;
  1420.      begin
  1421.        Byte (a) := 1;
  1422.        if a then WriteLn ('Ord (True) = 1')
  1423.      end.
  1424.  
  1425. See also
  1426. --------
  1427.  
  1428. 
  1429. File: gpc.info,  Node: ByteCard,  Next: ByteInt,  Prev: ByteBool,  Up: Reference
  1430.  
  1431. ByteCard
  1432. ========
  1433.  
  1434. Synopsis
  1435. --------
  1436.  
  1437.      type
  1438.        ByteCard = Cardinal (BitSizeOf (Byte));
  1439.  
  1440. Description
  1441. -----------
  1442.  
  1443.    `ByteCard' is an unsigned integer type which is one "unit" wide.  On
  1444. most platforms one unit has 8 bits, therefore the type is prefixed
  1445. "byte-" and usually has a range of `0..255'.
  1446.  
  1447.    `ByteCard' in GNU Pascal is compatible to `unsigned char' in GNU C.
  1448.  
  1449.    There are lots of other integer types in GPC, see *Note Integer
  1450. Types::.
  1451.  
  1452. Conforming to
  1453. -------------
  1454.  
  1455.    `ByteCard' is a GNU Pascal extension.
  1456.  
  1457. Example
  1458. -------
  1459.  
  1460.      program ByteCardDemo;
  1461.      var
  1462.        a: ByteCard;
  1463.      begin
  1464.        a := 42;
  1465.        WriteLn (a)
  1466.      end.
  1467.  
  1468. See also
  1469. --------
  1470.  
  1471.    *Note Integer Types::, *Note Subrange Types::.
  1472.  
  1473. 
  1474. File: gpc.info,  Node: ByteInt,  Next: C,  Prev: ByteCard,  Up: Reference
  1475.  
  1476. ByteInt
  1477. =======
  1478.  
  1479. Synopsis
  1480. --------
  1481.  
  1482.      type
  1483.        ByteInt = Integer (BitSizeOf (Byte));
  1484.  
  1485. Description
  1486. -----------
  1487.  
  1488.    `ByteInt' is a signed integer type which is one "unit" wide.  On
  1489. most platforms one unit has 8 bits, therefore the type is prefixed
  1490. "byte-" and usually has a range of `-128..127'.
  1491.  
  1492.    `ByteInt' in GNU Pascal is compatible to `signed char' in GNU C.
  1493.  
  1494.    There are lots of other integer types in GPC, see *Note Integer
  1495. Types::.
  1496.  
  1497. Conforming to
  1498. -------------
  1499.  
  1500.    `ByteInt' is a GNU Pascal extension.
  1501.  
  1502.    `ByteInt' in GNU Pascal corresponds to *Note ShortInt:: in Borland
  1503. Pascal.
  1504.  
  1505. Example
  1506. -------
  1507.  
  1508.      program ByteIntDemo;
  1509.      var
  1510.        a: ByteInt;
  1511.      begin
  1512.        a := 42;
  1513.        WriteLn (a)
  1514.      end.
  1515.  
  1516. See also
  1517. --------
  1518.  
  1519.    *Note Integer Types::, *Note Subrange Types::.
  1520.  
  1521. 
  1522. File: gpc.info,  Node: C,  Next: Card,  Prev: ByteInt,  Up: Reference
  1523.  
  1524. C
  1525. =
  1526.  
  1527.    (Under construction.)
  1528.  
  1529. Synopsis
  1530. --------
  1531.  
  1532. Description
  1533. -----------
  1534.  
  1535. Conforming to
  1536. -------------
  1537.  
  1538. Example
  1539. -------
  1540.  
  1541. See also
  1542. --------
  1543.  
  1544.    *Note Importing Libraries from Other Languages::, *Note C_Language::
  1545.  
  1546. 
  1547. File: gpc.info,  Node: Card,  Next: Cardinal,  Prev: C,  Up: Reference
  1548.  
  1549. Card
  1550. ====
  1551.  
  1552. Synopsis
  1553. --------
  1554.  
  1555.      function Card (S: ANY SET): Integer;
  1556.  
  1557. Description
  1558. -----------
  1559.  
  1560.    The function `Card (S)' returns the number of elements in the set
  1561. `S'.
  1562.  
  1563. Conforming to
  1564. -------------
  1565.  
  1566.    `Card' is an ISO 10206 Extended Pascal extension.
  1567.  
  1568. Example
  1569. -------
  1570.  
  1571.      program CardDemo;
  1572.      var
  1573.        Foo: set of 1 .. 100;
  1574.      begin
  1575.        Foo := [1, 2, 3, 5, 1, 1, 1, 2, 2, 2, 3, 3, 5, 5];  { four elements }
  1576.        WriteLn ('foo consists of ', Card (Foo), ' elements')
  1577.      end.
  1578.  
  1579. See also
  1580. --------
  1581.  
  1582.    *Note set::
  1583.  
  1584. 
  1585. File: gpc.info,  Node: Cardinal,  Next: case,  Prev: Card,  Up: Reference
  1586.  
  1587. Cardinal
  1588. ========
  1589.  
  1590. Synopsis
  1591. --------
  1592.  
  1593.      type
  1594.        Cardinal  { built-in type }
  1595.    or
  1596.      type
  1597.        Cardinal (n)  { built-in type class }
  1598.  
  1599. Description
  1600. -----------
  1601.  
  1602.    `Cardinal' is the "natural" unsigned integer type in GNU Pascal.  On
  1603. most platforms it is 32 bits wide and thus has a range of
  1604. `0..4294967295'. Use it whenever you need a general-purpose unsigned
  1605. integer type and don't need to care about compatibility to other Pascal
  1606. dialects.
  1607.  
  1608.    As an extension, GPC allows to use `Cardinal' as a pseudo-schema to
  1609. produce types with a specified size in bits; for example
  1610.  
  1611.      type
  1612.        Card16 = Cardinal (16);
  1613.  
  1614. defines an unsigned integer type with 16 bits. The same mechanism works
  1615. for `Integer' and `Word', too.
  1616.  
  1617.    `Cardinal' in GNU Pascal is compatible to `unsigned int' in GNU C.
  1618.  
  1619.    There are lots of other integer types in GPC, see *Note Integer
  1620. Types::.
  1621.  
  1622. Conforming to
  1623. -------------
  1624.  
  1625.    `Cardinal' is not defined in ISO Pascal, but several Pascal
  1626. compilers support it as an extension. In Borland Delphi, for instance,
  1627. it is an unsigned 16-bit in version 1.0, an unsigned 31-bit integer
  1628. from version 2.0 on, and an unsigned 32-bit integer from version 4.0 on.
  1629.  
  1630. Example
  1631. -------
  1632.  
  1633.      program CardinalDemo;
  1634.      var
  1635.        a: Cardinal;
  1636.      begin
  1637.        a := 42;
  1638.        WriteLn (a)
  1639.      end.
  1640.  
  1641. See also
  1642. --------
  1643.  
  1644.    *Note Integer Types::, *Note Subrange Types::.
  1645.  
  1646. 
  1647. File: gpc.info,  Node: case,  Next: Char,  Prev: Cardinal,  Up: Reference
  1648.  
  1649. case
  1650. ====
  1651.  
  1652. Synopsis
  1653. --------
  1654.  
  1655.      case EXPRESSION of
  1656.        SELECTOR: STATEMENT;
  1657.        ...
  1658.        SELECTOR: STATEMENT;
  1659.      end;
  1660.    or, with alternative statement sequence:
  1661.      case EXPRESSION of
  1662.        SELECTOR: STATEMENT;
  1663.        ...
  1664.        SELECTOR: STATEMENT;
  1665.      otherwise                   { ``else'' instead of ``otherwise'' is allowed }
  1666.        STATEMENT;
  1667.        ...
  1668.        STATEMENT;
  1669.      end;
  1670.    or, as part of the invariant `record' type definition:
  1671.      foo = record
  1672.        FIELD DECLARATIONS
  1673.      case bar: VARIANT TYPE of
  1674.        SELECTOR: (FIELD DECLARATIONS);
  1675.        SELECTOR: (FIELD DECLARATIONS);
  1676.        ...
  1677.      end;
  1678.    or, without a variant selector field,
  1679.      foo = record
  1680.        FIELD DECLARATIONS
  1681.      case VARIANT TYPE of
  1682.        SELECTOR: (FIELD DECLARATIONS);
  1683.        SELECTOR: (FIELD DECLARATIONS);
  1684.        ...
  1685.      end;
  1686.  
  1687. Description
  1688. -----------
  1689.  
  1690.    `case' opens a case statement. For further description see *Note
  1691. case Statement::.
  1692.  
  1693.    For `case' in a variant record type definition, see *Note Record
  1694. Types::.
  1695.  
  1696. Conforming to
  1697. -------------
  1698.  
  1699.    The `case' statement is defined in ISO-7185 Standard Pascal and
  1700. supported by all known Pascal variants.
  1701.  
  1702.    According to ISO 7185 Pascal, the selector type must be a named type.
  1703. GNU Pascal, UCSD and Borland Pascal also allow a subrange here.
  1704.  
  1705.    The alternative statement execution with `otherwise' it is an
  1706. Extended Pascal extension; with `else' it is a Borland Pascal
  1707. extension. In GNU Pascal, both are allowed.
  1708.  
  1709. Example
  1710. -------
  1711.  
  1712.      program CaseDemo;
  1713.      var
  1714.        Foo: String (10);
  1715.        Bar: Integer;
  1716.      begin
  1717.        WriteLn ('Enter up to ten arbitrary characters:');
  1718.        ReadLn (Foo);
  1719.        for Bar := 1 to Length (Foo) do
  1720.          begin
  1721.            Write (Foo [bar], ' is ');
  1722.            case Foo [bar] of
  1723.              'A' .. 'Z', 'a' .. 'z':
  1724.                WriteLn ('an English letter');
  1725.              '0' .. '9':
  1726.                WriteLn ('a number');
  1727.            otherwise
  1728.              WriteLn ('an unrecognized character')
  1729.            end
  1730.          end
  1731.      end.
  1732.  
  1733. See also
  1734. --------
  1735.  
  1736.    *Note if Statement::, *Note Record Types::
  1737.  
  1738. 
  1739. File: gpc.info,  Node: Char,  Next: ChDir,  Prev: case,  Up: Reference
  1740.  
  1741. Char
  1742. ====
  1743.  
  1744.    (Under construction.)
  1745.  
  1746. Synopsis
  1747. --------
  1748.  
  1749.      type
  1750.        Char  { built-in type }
  1751.  
  1752. Description
  1753. -----------
  1754.  
  1755. Conforming to
  1756. -------------
  1757.  
  1758.    `Char' is defined in ISO-7185 Standard Pascal and supported by all
  1759. known Pascal variants.
  1760.  
  1761. Example
  1762. -------
  1763.  
  1764.      program CharDemo;
  1765.      var
  1766.        a: Char;
  1767.      begin
  1768.        a := 'x';
  1769.        WriteLn (a)
  1770.      end.
  1771.  
  1772. See also
  1773. --------
  1774.  
  1775. 
  1776. File: gpc.info,  Node: ChDir,  Next: Chr,  Prev: Char,  Up: Reference
  1777.  
  1778. ChDir
  1779. =====
  1780.  
  1781. Synopsis
  1782. --------
  1783.  
  1784.      procedure ChDir (Directory: String);
  1785.  
  1786. Description
  1787. -----------
  1788.  
  1789.    `ChDir' changes the current directory to DIRECTORY, if its argument
  1790. is a valid parameter to the related operating system's function.
  1791. Otherwise, a runtime error is caused.
  1792.  
  1793. Conforming to
  1794. -------------
  1795.  
  1796.    `ChDir' is a Borland Pascal extension.
  1797.  
  1798. Example
  1799. -------
  1800.  
  1801.      program ChDirDemo;
  1802.      var
  1803.        Foo: String (127);
  1804.      begin
  1805.        WriteLn ('Enter directory name to change to:');
  1806.        ReadLn (Foo);
  1807.        {$I-}  { Don't abort the program on error }
  1808.        ChDir (Foo);
  1809.        if IOResult <> 0 then
  1810.          WriteLn ('Cannot change to directory `', foo, '''.')
  1811.        else
  1812.          WriteLn ('Okay.')
  1813.      end.
  1814.  
  1815. See also
  1816. --------
  1817.  
  1818.    *Note MkDir::, *Note RmDir::
  1819.  
  1820. 
  1821. File: gpc.info,  Node: Chr,  Next: C_Language,  Prev: ChDir,  Up: Reference
  1822.  
  1823. Chr
  1824. ===
  1825.  
  1826. Synopsis
  1827. --------
  1828.  
  1829.      function Chr (AsciiCode: Integer): Char;
  1830.  
  1831. Description
  1832. -----------
  1833.  
  1834.    `Chr' returns a character whose ASCII code corresponds to the value
  1835. given by `AsciiCode'.
  1836.  
  1837. Conforming to
  1838. -------------
  1839.  
  1840.    `Chr' is defined in ISO-7185 Standard Pascal and supported by all
  1841. known Pascal variants.
  1842.  
  1843. Example
  1844. -------
  1845.  
  1846.      program ChrDemo;
  1847.      var
  1848.        x: Integer;
  1849.      begin
  1850.        for x := 32 to 122 do
  1851.          Write (Chr (x))
  1852.      end.
  1853.  
  1854. See also
  1855. --------
  1856.  
  1857.    *Note Ord::
  1858.  
  1859. 
  1860. File: gpc.info,  Node: C_Language,  Next: class,  Prev: Chr,  Up: Reference
  1861.  
  1862. C_Language
  1863. ==========
  1864.  
  1865.    (Under construction.)
  1866.  
  1867. Synopsis
  1868. --------
  1869.  
  1870. Description
  1871. -----------
  1872.  
  1873. Conforming to
  1874. -------------
  1875.  
  1876. Example
  1877. -------
  1878.  
  1879. See also
  1880. --------
  1881.  
  1882.    *Note Importing Libraries from Other Languages::, *Note C::
  1883.  
  1884. 
  1885. File: gpc.info,  Node: class,  Next: Close,  Prev: C_Language,  Up: Reference
  1886.  
  1887. class
  1888. =====
  1889.  
  1890.    Not yet implemented.
  1891.  
  1892. Synopsis
  1893. --------
  1894.  
  1895. Description
  1896. -----------
  1897.  
  1898. Conforming to
  1899. -------------
  1900.  
  1901. Example
  1902. -------
  1903.  
  1904. See also
  1905. --------
  1906.  
  1907. 
  1908. File: gpc.info,  Node: Close,  Next: Cmplx,  Prev: class,  Up: Reference
  1909.  
  1910. Close
  1911. =====
  1912.  
  1913.    (Under construction.)
  1914.  
  1915. Synopsis
  1916. --------
  1917.  
  1918.      procedure Close (var F: ANY FILE);
  1919.  
  1920. Description
  1921. -----------
  1922.  
  1923. Conforming to
  1924. -------------
  1925.  
  1926. Example
  1927. -------
  1928.  
  1929. See also
  1930. --------
  1931.  
  1932. 
  1933. File: gpc.info,  Node: Cmplx,  Next: Comp,  Prev: Close,  Up: Reference
  1934.  
  1935. Cmplx
  1936. =====
  1937.  
  1938. Synopsis
  1939. --------
  1940.  
  1941.      function Cmplx (RealPart, ImaginaryPart: Real): Complex;
  1942.  
  1943. Description
  1944. -----------
  1945.  
  1946.    `Cmplx' makes a complex number from `RealPart' and `ImaginaryPart'.
  1947.  
  1948. Conforming to
  1949. -------------
  1950.  
  1951.    `Cmplx' is an ISO-10206 Extended Pascal extension.
  1952.  
  1953. Example
  1954. -------
  1955.  
  1956.      program CmplxDemo;
  1957.      var
  1958.        z: Complex;
  1959.        x, y: Real;
  1960.      begin
  1961.        z := Cmplx (x, y)  { z := x + iy }
  1962.      end.
  1963.  
  1964. See also
  1965. --------
  1966.  
  1967.    *Note Re::, *Note Im::, *Note Polar::, *Note Arg::
  1968.  
  1969. 
  1970. File: gpc.info,  Node: Comp,  Next: Complex,  Prev: Cmplx,  Up: Reference
  1971.  
  1972. Comp
  1973. ====
  1974.  
  1975. Synopsis
  1976. --------
  1977.  
  1978.      type
  1979.        Comp = LongInt;
  1980.  
  1981. Description
  1982. -----------
  1983.  
  1984.    `Comp' is a signed integer type which is longer than `Integer'.  On
  1985. most platforms it is 64 bits wide and thus has a range of
  1986. `-9223372036854775808..9223372036854775807'.
  1987.  
  1988.    There are lots of other integer types in GPC, see *Note Integer
  1989. Types::.
  1990.  
  1991. Conforming to
  1992. -------------
  1993.  
  1994.    `Comp' is a Borland Pascal extension.
  1995.  
  1996.    In some contexts, Borland Pascal treats `Comp' as a "real" type -
  1997. this behaviour is not supported by GPC.
  1998.  
  1999. Example
  2000. -------
  2001.  
  2002.      program CompDemo;
  2003.      var
  2004.        a: Comp;
  2005.      begin
  2006.        a := 42;
  2007.        WriteLn (a)
  2008.      end.
  2009.  
  2010. See also
  2011. --------
  2012.  
  2013.    *Note Integer Types::, *Note Subrange Types::.
  2014.  
  2015. 
  2016. File: gpc.info,  Node: Complex,  Next: Concat,  Prev: Comp,  Up: Reference
  2017.  
  2018. Complex
  2019. =======
  2020.  
  2021.    (Under construction.)
  2022.  
  2023. Synopsis
  2024. --------
  2025.  
  2026.      type
  2027.        Internal_Complex = record { not visible }
  2028.          RealPart, ImaginaryPart: Real
  2029.        end;
  2030.        Complex = restricted Internal_Complex;
  2031.  
  2032. Description
  2033. -----------
  2034.  
  2035. Conforming to
  2036. -------------
  2037.  
  2038.    `Complex' is an ISO-10206 Extended Pascal extension.
  2039.  
  2040. Example
  2041. -------
  2042.  
  2043.      program ComplexDemo;
  2044.      var
  2045.        a: Complex;
  2046.      begin
  2047.        a := Cmplx (42, 3);
  2048.        WriteLn (Re (a), ' + ', Im (a), ' i')
  2049.      end.
  2050.  
  2051. See also
  2052. --------
  2053.  
  2054. 
  2055. File: gpc.info,  Node: Concat,  Next: Conjugate,  Prev: Complex,  Up: Reference
  2056.  
  2057. Concat
  2058. ======
  2059.  
  2060.    (Under construction.)
  2061.  
  2062. Synopsis
  2063. --------
  2064.  
  2065.      function Concat (S1, S2: String): String;
  2066.    or
  2067.      function Concat (S1, S2, S3: String): String;
  2068.    or
  2069.      ...
  2070.  
  2071. Description
  2072. -----------
  2073.  
  2074. Conforming to
  2075. -------------
  2076.  
  2077.    `Concat' is a UCSD Pascal extension.
  2078.  
  2079. Example
  2080. -------
  2081.  
  2082. See also
  2083. --------
  2084.  
  2085. 
  2086. File: gpc.info,  Node: Conjugate,  Next: const,  Prev: Concat,  Up: Reference
  2087.  
  2088. Conjugate
  2089. =========
  2090.  
  2091. Synopsis
  2092. --------
  2093.  
  2094.      function Conjugate (z: Complex): Complex;
  2095.  
  2096. Description
  2097. -----------
  2098.  
  2099.    `Conjugate' computes the complex conjugate of the complex number `z'
  2100.  
  2101. Conforming to
  2102. -------------
  2103.  
  2104.    `Conjugate' is an ISO-10206 Extended Pascal extension.
  2105.  
  2106. Example
  2107. -------
  2108.  
  2109.      program ConjugateDemo;
  2110.      var
  2111.        z: Complex;
  2112.      begin
  2113.        z := Cmplx (2, 3);  { z is 2 + i * 3 }
  2114.        WriteLn ('z = ', Re (z) : 0 : 5, ' + i * ', Im (z) : 0 : 5);
  2115.        z := Conjugate (z);  { z conjugate is 2 - i * 3 }
  2116.        WriteLn ('z conjugate = ', Re (z) : 0 : 5,' + i * ', Im (z) : 0 : 5)
  2117.      end.
  2118.  
  2119. See also
  2120. --------
  2121.  
  2122.    *Note Cmplx::, *Note Re::, *Note Im::, *Note Abs::
  2123.  
  2124. 
  2125. File: gpc.info,  Node: const,  Next: constructor,  Prev: Conjugate,  Up: Reference
  2126.  
  2127. const
  2128. =====
  2129.  
  2130.    (Under construction.)
  2131.  
  2132. Synopsis
  2133. --------
  2134.  
  2135. Description
  2136. -----------
  2137.  
  2138. Conforming to
  2139. -------------
  2140.  
  2141.    `const' is defined in ISO-7185 Standard Pascal and supported by all
  2142. known Pascal variants.
  2143.  
  2144. Example
  2145. -------
  2146.  
  2147. See also
  2148. --------
  2149.  
  2150. 
  2151. File: gpc.info,  Node: constructor,  Next: Continue,  Prev: const,  Up: Reference
  2152.  
  2153. constructor
  2154. ===========
  2155.  
  2156.    (Under construction.)
  2157.  
  2158. Synopsis
  2159. --------
  2160.  
  2161. Description
  2162. -----------
  2163.  
  2164. Conforming to
  2165. -------------
  2166.  
  2167.    `constructor' is a Borland Pascal extension.
  2168.  
  2169. Example
  2170. -------
  2171.  
  2172. See also
  2173. --------
  2174.  
  2175. 
  2176. File: gpc.info,  Node: Continue,  Next: Copy,  Prev: constructor,  Up: Reference
  2177.  
  2178. Continue
  2179. ========
  2180.  
  2181. Synopsis
  2182. --------
  2183.  
  2184.      Continue  { simple statement }
  2185.  
  2186. Description
  2187. -----------
  2188.  
  2189.    `Continue' goes on with loop iteration by jumping to the end of the
  2190. current loop body. Note: `Continue' can only stand within a WHILE,
  2191. REPEAT or a FOR statement.
  2192.  
  2193. Conforming to
  2194. -------------
  2195.  
  2196.    `Continue' is a Borland Pascal extension.
  2197.  
  2198. Example
  2199. -------
  2200.  
  2201.      program ContinueDemo;
  2202.      var
  2203.        Foo, Bar: Integer;
  2204.      begin
  2205.        WriteLn ('Enter three numbers:');
  2206.        for Bar := 1 to 3 do
  2207.          begin
  2208.            ReadLn (Foo);
  2209.            if Foo < 5 then
  2210.              Continue;
  2211.            WriteLn ('Your number was greater then 5.')
  2212.          end
  2213.      end.
  2214.  
  2215. See also
  2216. --------
  2217.  
  2218.    *Note Loop Control Statements::, *Note Break::, *Note Exit::, *Note
  2219. Halt::, *Note Return::, *Note goto::.
  2220.  
  2221. 
  2222. File: gpc.info,  Node: Copy,  Next: Cos,  Prev: Continue,  Up: Reference
  2223.  
  2224. Copy
  2225. ====
  2226.  
  2227. Synopsis
  2228. --------
  2229.  
  2230.      function Copy (S: String; FirstChar, Count: Integer): String;
  2231.    or
  2232.      function Copy (S: String; FirstChar: Integer): String;
  2233.  
  2234. Description
  2235. -----------
  2236.  
  2237.    `Copy' returns a sub-string of `S' starting with the character at
  2238. position FIRSTCHAR. If COUNT is given, such many characters will be
  2239. copied into the sub-string. If COUNT is omitted, the sub-string will
  2240. will range to the end of S.
  2241.  
  2242.    If `Count' is too large for the sub-string to fit in S, the result
  2243. will be truncated at the end of S. If `FirstChar' exceeds the length of
  2244. S, the empty string will be returned. (For a function which does not
  2245. truncate but triggers a runtime error instead, see *Note SubStr::.)
  2246.  
  2247.    Please note that GPC's strings may be longer than 255 characters. If
  2248. you want to isolate the second half of a string S starting with the
  2249. third character, use `Copy (S, 3)' instead of `Copy (S, 3, 255)'.
  2250.  
  2251. Conforming to
  2252. -------------
  2253.  
  2254.    `Copy' is a UCSD Pascal extension. The possibility to omit the third
  2255. parameter is a GNU Pascal extension.
  2256.  
  2257. Example
  2258. -------
  2259.  
  2260.      program CopyDemo;
  2261.      var
  2262.        S: String (42);
  2263.      begin
  2264.        S := 'Hello';
  2265.        WriteLn (Copy (S, 2, 3));  { yields "ell" }
  2266.        WriteLn (Copy (S, 3));     { yields "llo" }
  2267.        WriteLn (Copy (S, 4, 7));  { yields "lo" }
  2268.        WriteLn (Copy (S, 42))     { yields the empty string }
  2269.      end.
  2270.  
  2271. See also
  2272. --------
  2273.  
  2274.    *Note SubStr::, String slice access.
  2275.  
  2276. 
  2277. File: gpc.info,  Node: Cos,  Next: CString,  Prev: Copy,  Up: Reference
  2278.  
  2279. Cos
  2280. ===
  2281.  
  2282. Synopsis
  2283. --------
  2284.  
  2285.      function Cos (x: Real): Real;
  2286.    or
  2287.      function Cos (z: Complex): Complex;
  2288.  
  2289. Description
  2290. -----------
  2291.  
  2292.    `Cos' returns the cosine of the argument.  The result is in the
  2293. range `-1 < Cos (x) < 1' for real arguments.
  2294.  
  2295. Conforming to
  2296. -------------
  2297.  
  2298.    The function `Cos' is defined in ISO-7185 Standard Pascal; its
  2299. application to complex values is defined in ISO-10206 Extended Pascal.
  2300.  
  2301. Example
  2302. -------
  2303.  
  2304.      program CosDemo;
  2305.      begin
  2306.        WriteLn (Cos (SqRt (2) / 2) : 0 : 5)
  2307.          { yields 0.5 since Cos (SqRt (2) / 2) = 0.5 }
  2308.      end.
  2309.  
  2310. See also
  2311. --------
  2312.  
  2313.    *Note ArcTan::, *Note Sin::, *Note Ln::, *Note Arg::.
  2314.  
  2315. 
  2316. File: gpc.info,  Node: CString,  Next: CString2String,  Prev: Cos,  Up: Reference
  2317.  
  2318. CString
  2319. =======
  2320.  
  2321.    (Under construction.)
  2322.  
  2323. Synopsis
  2324. --------
  2325.  
  2326.      type
  2327.        CString = ^Char;
  2328.  
  2329. Description
  2330. -----------
  2331.  
  2332. Conforming to
  2333. -------------
  2334.  
  2335. Example
  2336. -------
  2337.  
  2338.      program CStringDemo;
  2339.      var
  2340.        s: CString;
  2341.      begin
  2342.        s := 'Hello, world!';
  2343.        {$X+}
  2344.        WriteLn (s)
  2345.      end.
  2346.  
  2347. See also
  2348. --------
  2349.  
  2350. 
  2351. File: gpc.info,  Node: CString2String,  Next: CStringCopyString,  Prev: CString,  Up: Reference
  2352.  
  2353. CString2String
  2354. ==============
  2355.  
  2356.    (Under construction.)
  2357.  
  2358. Synopsis
  2359. --------
  2360.  
  2361.      function CString2String (S: CString): String;
  2362.  
  2363. Description
  2364. -----------
  2365.  
  2366. Conforming to
  2367. -------------
  2368.  
  2369. Example
  2370. -------
  2371.  
  2372. See also
  2373. --------
  2374.  
  2375. 
  2376. File: gpc.info,  Node: CStringCopyString,  Next: Date,  Prev: CString2String,  Up: Reference
  2377.  
  2378. CStringCopyString
  2379. =================
  2380.  
  2381.    (Under construction.)
  2382.  
  2383. Synopsis
  2384. --------
  2385.  
  2386.      function CStringCopyString (Dest: CString; const Source: String): CString;
  2387.  
  2388. Description
  2389. -----------
  2390.  
  2391. Conforming to
  2392. -------------
  2393.  
  2394. Example
  2395. -------
  2396.  
  2397. See also
  2398. --------
  2399.  
  2400. 
  2401. File: gpc.info,  Node: Date,  Next: Dec,  Prev: CStringCopyString,  Up: Reference
  2402.  
  2403. Date
  2404. ====
  2405.  
  2406.    (Under construction.)
  2407.  
  2408. Synopsis
  2409. --------
  2410.  
  2411.      function Date (T: TimeStamp): packed array [1 .. DATE LENGTH] of Char;
  2412.  
  2413. Description
  2414. -----------
  2415.  
  2416. Conforming to
  2417. -------------
  2418.  
  2419. Example
  2420. -------
  2421.  
  2422. See also
  2423. --------
  2424.  
  2425. 
  2426. File: gpc.info,  Node: Dec,  Next: DefineSize,  Prev: Date,  Up: Reference
  2427.  
  2428. Dec
  2429. ===
  2430.  
  2431. Synopsis
  2432. --------
  2433.  
  2434.    For ordinal types:
  2435.      procedure Dec (var x: ORDINAL TYPE);
  2436.    or
  2437.      procedure Dec (var x: ORDINAL TYPE; Amount: Integer);
  2438.  
  2439.    For pointer types:
  2440.      procedure Dec (var p: ANY POINTER TYPE);
  2441.    or
  2442.      procedure Dec (var p: ANY POINTER TYPE; Amount: Integer);
  2443.  
  2444. Description
  2445. -----------
  2446.  
  2447.    For ordinal types, `Dec' decreases the value of `x' by one or by
  2448. `amount' if specified.
  2449.  
  2450.    If the argument `p' is pointing to a specified type (typed pointer),
  2451. `Dec' decreases the address of `p' by the size of the type `p' is
  2452. pointing to or by `amount' times that size respectively. If `p' is an
  2453. untyped pointer (i.e. `p' is of type *Note Pointer::), `p' is decreased
  2454. by one, otherwise by `amount' if specified.
  2455.  
  2456. Conforming to
  2457. -------------
  2458.  
  2459.    `Dec' is a Borland Pascal extension. The combination of the second
  2460. argument with application to pointers is a GNU extension.
  2461.  
  2462. Example
  2463. -------
  2464.  
  2465.      program DecDemo;
  2466.      var
  2467.        x: Integer;
  2468.        y: array [1 .. 5] of Integer;
  2469.        p: ^Integer;
  2470.      begin
  2471.        x := 9;
  2472.        Dec (x, 10);     { yields -1 }
  2473.        {$X+}            { Turn on extended systax }
  2474.        p := @y [5];     { p points to y [5] }
  2475.        Dec (p, 3)       { p points to y [2] }
  2476.      end.
  2477.  
  2478. See also
  2479. --------
  2480.  
  2481.    *Note Inc::, *Note Pred::, *Note Succ::, *Note Pointer Arithmetics::.
  2482.  
  2483. 
  2484. File: gpc.info,  Node: DefineSize,  Next: Delete,  Prev: Dec,  Up: Reference
  2485.  
  2486. DefineSize
  2487. ==========
  2488.  
  2489.    (Under construction.)
  2490.  
  2491. Synopsis
  2492. --------
  2493.  
  2494.      procedure DefineSize (var F: ANY FILE; NewSize: Integer);
  2495.  
  2496. Description
  2497. -----------
  2498.  
  2499. Conforming to
  2500. -------------
  2501.  
  2502.    `DefineSize' is an ISO-10206 Extended Pascal extension.
  2503.  
  2504. Example
  2505. -------
  2506.  
  2507. See also
  2508. --------
  2509.  
  2510. 
  2511. File: gpc.info,  Node: Delete,  Next: destructor,  Prev: DefineSize,  Up: Reference
  2512.  
  2513. Delete
  2514. ======
  2515.  
  2516.    (Under construction.)
  2517.  
  2518. Synopsis
  2519. --------
  2520.  
  2521.      procedure Delete (var S: String; FirstChar, Count: Integer);
  2522.  
  2523. Description
  2524. -----------
  2525.  
  2526. Conforming to
  2527. -------------
  2528.  
  2529.    `Delete' is a UCSD Pascal extension.
  2530.  
  2531. Example
  2532. -------
  2533.  
  2534. See also
  2535. --------
  2536.  
  2537. 
  2538. File: gpc.info,  Node: destructor,  Next: Dispose,  Prev: Delete,  Up: Reference
  2539.  
  2540. destructor
  2541. ==========
  2542.  
  2543.    (Under construction.)
  2544.  
  2545. Synopsis
  2546. --------
  2547.  
  2548. Description
  2549. -----------
  2550.  
  2551. Conforming to
  2552. -------------
  2553.  
  2554.    `destructor' is a Borland Pascal extension.
  2555.  
  2556. Example
  2557. -------
  2558.  
  2559. See also
  2560. --------
  2561.  
  2562. 
  2563. File: gpc.info,  Node: Dispose,  Next: div,  Prev: destructor,  Up: Reference
  2564.  
  2565. Dispose
  2566. =======
  2567.  
  2568.    (Under construction.)
  2569.  
  2570. Synopsis
  2571. --------
  2572.  
  2573.      Dispose (PointerVar: Pointer);
  2574.    or
  2575.      Dispose (PointerVar: Pointer; TAG FIELD VALUES);
  2576.    or
  2577.      Dispose (ObjectPointerVar: Pointer; DESTRUCTOR CALL);
  2578.  
  2579. Description
  2580. -----------
  2581.  
  2582. Conforming to
  2583. -------------
  2584.  
  2585.    `Dispose' is defined in ISO-7185 Standard Pascal and supported by
  2586. most known Pascal variants, but not by UCSD Pascal.  Its use for
  2587. objects is a Borland Pascal extension.
  2588.  
  2589. Example
  2590. -------
  2591.  
  2592. See also
  2593. --------
  2594.  
  2595. 
  2596. File: gpc.info,  Node: div,  Next: do,  Prev: Dispose,  Up: Reference
  2597.  
  2598. div
  2599. ===
  2600.  
  2601.    (Under construction.)
  2602.  
  2603. Synopsis
  2604. --------
  2605.  
  2606.      operator div (p, q: Integer) = r: Integer;
  2607.  
  2608. Description
  2609. -----------
  2610.  
  2611. Conforming to
  2612. -------------
  2613.  
  2614.    `div' is defined in ISO-7185 Standard Pascal and supported by all
  2615. known Pascal variants.
  2616.  
  2617. Example
  2618. -------
  2619.  
  2620. See also
  2621. --------
  2622.  
  2623.